warn Object.create exists, uninstalled
    <section class="suite">
      <h1>#Object</h1>
      <dl>
        <section class="suite">
          <h1>Predicates</h1>
          <dl>
            <section class="suite">
              <h1>#isNull</h1>
              <dl>
                <dt>Object.isNull(obj)</dt>
                <dd><pre><code>assert.equal(Object.isNull(null), true);
assert.equal(Object.isNull(undefined), true)
assert.equal(Object.isNull(void 0), true)</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#notNull</h1>
              <dl>
                <dt>Object.notNull</dt>
                <dd><pre><code>assert.equal(Object.notNull({}), true)
assert.equal(Object.notNull([]), true)</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#isEmpty</h1>
              <dl>
                <dt>Object.isEmpty(obj)</dt>
                <dd><pre><code>assert.equal(Object.isEmpty(''), true)
assert.equal(Object.isEmpty([]), true)
assert.equal(Object.isEmpty(['a']), false)
assert.equal(Object.isEmpty({}), true)
assert.equal(Object.isEmpty({
    a: 'a'
}), false)
assert.equal(Object.isEmpty(null), true)
assert.equal(Object.isEmpty(void 0), true)
assert.equal(Object.isEmpty('sdd'), false)</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#notEmpty</h1>
              <dl>
                <dt>Object.notEmpty(obj)</dt>
                <dd><pre><code>assert.equal(Object.notEmpty(''), false)
assert.equal(Object.notEmpty([]), false)
assert.equal(Object.notEmpty(['a']), true)
assert.equal(Object.notEmpty({}), false)
assert.equal(Object.notEmpty({
    a: 'a'
}), true)
assert.equal(Object.notEmpty(null), false)
assert.equal(Object.notEmpty(void 0), false)
assert.equal(Object.notEmpty('sdd'), true)</code></pre></dd>
              </dl>
            </section>
          </dl>
        </section>
        <section class="suite">
          <h1>Asserts &amp; Utils</h1>
          <dl>
            <section class="suite">
              <h1>#getOrCreate -- try to get a property of object, or create the property if it is not defined </h1>
              <dl>
                <dt>obj.getOrCreate(name, [newObejct])</dt>
                <dd><pre><code>var a = {};
var b = a.getOrCreate('name', 'yxc');
assert.deepEqual(a, {
    name: 'yxc'
});
assert.deepEqual(b, 'yxc');</code></pre></dd>
                <dt>obj.getOrCreate(name,newObject) -- should keep null/undefined without operations</dt>
                <dd><pre><code>var a = {
    name: null,
    value: undefined
}
var name = a.getOrCreate('name', 'yxc');
assert.equal(name, null);
var name1 = a.getOrCreate('value', 'yxc');
assert.equal(name1, undefined);</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#getOrDefault -- try to get a property of object, or get the default value if it is not defined or null</h1>
              <dl>
                <dt>obj.getOrDefault(name,default)</dt>
                <dd><pre><code>var a = {'n':null,'y':'yes'};
assert(a.getOrDefault('name','yxc'),'yxc');
assert(a.getOrDefault('n','yxc'),'yxc');
assert(a.getOrDefault('y','yxc'),'yes');</code></pre></dd>
              </dl>
            </section>
          </dl>
        </section>
        <section class="suite">
          <h1>#extend -- extend obejct from RIGHT TO LEFT</h1>
          <dl>
            <dt>obj.extend({},{},...)</dt>
            <dd><pre><code>assert.deepEqual({
    name: 'empty'
}.extend(a, b), {
    a: 'a',
    b: 'b',
    c: 'c',
    name: 'empty'
});</code></pre></dd>
            <dt>Object.extend({},a,b,c ....)</dt>
            <dd><pre><code>assert.deepEqual(Object.extend({
    name: 'empty'
}, a, b), {
    a: 'a',
    b: 'b',
    c: 'c',
    name: 'empty'
});</code></pre></dd>
          </dl>
        </section>
        <section class="suite">
          <h1>#pairs -- convert object to a array </h1>
          <dl>
            <dt>obj.pairs() -- pair to 2d-arrays</dt>
            <dd><pre><code>assert.deepEqual(example.pairs() ,[['a','a'],['b','b'],['c','c']])</code></pre></dd>
            <dt>obj.pairs(true) -- pair to name/value pairs</dt>
            <dd><pre><code>assert.deepEqual(example.pairs(true) ,[
        {name:'a',value:'a'},
        {name:'b',value:'b'},
        {name:'c',value:'c'} 
])</code></pre></dd>
          </dl>
        </section>
        <section class="suite">
          <h1>#create -- create objects using the input as prototype</h1>
          <dl>
            <dt>obj.create()</dt>
            <dd><pre><code>var cat = {
    miao: 'miao'
};
var another_cat = cat.create();
assert.equal(another_cat.miao, 'miao');</code></pre></dd>
            <dt>Object.create(obj)</dt>
            <dd><pre><code>var cat = {
    miao: 'miao'
};
var another_cat = Object.create(cat);
assert.equal(another_cat.miao, 'miao');</code></pre></dd>
          </dl>
        </section>
        <section class="suite">
          <h1>#tap -- call the interceptor &amp; return itself</h1>
          <dl>
            <dt>obj.tap(inter)</dt>
            <dd><pre><code>var a = {};
assert.equal(a.tap(function(_) {
    _.a = 'a';
}).a, 'a');</code></pre></dd>
            <dt>Object.tap(obj,inter)</dt>
            <dd><pre><code>var a = {};
assert.equal(Object.tap(a, function(_) {
    _.a = 'a';
}).a, 'a');</code></pre></dd>
          </dl>
        </section>
      </dl>
    </section>
    <section class="suite">
      <h1>#Function</h1>
      <dl>
        <section class="suite">
          <h1>#negate -- return a negated version of predicate</h1>
          <dl>
            <dt>fn.negate()</dt>
            <dd><pre><code>var isArray = Array.isArray;
var isNotArray = isArray.negate();
assert.equal(isNotArray({}), true);
assert.equal(isNotArray([]), false);</code></pre></dd>
            <dt>Function.negate(fn)</dt>
            <dd><pre><code>var isNotArray = Function.negate(Array.isArray);
assert.equal(isNotArray([]), false);</code></pre></dd>
          </dl>
        </section>
        <section class="suite">
          <h1>#noop -- do nothing</h1>
          <dl>
            <dt>NOOP MEANS NOTHING TO DO </dt>
            <dd><pre><code>assert.equal(
    Array.filter(Function.noop.toString(), function(_) {
        return _ !== ' '
    }).join(''),
    'function(){}');</code></pre></dd>
          </dl>
        </section>
        <section class="suite">
          <h1>curry -- curry function</h1>
          <dl>
            <dt>fn.curry()</dt>
            <dd><pre><code>var add = function(a, b, c, d, e) {
    return a + b + c + d + e;
};
var curryAll = add.curry();
assert.equal(curryAll(1)(2)(3)(4)(5), 15);</code></pre></dd>
            <dt>Function.curry(fn)</dt>
            <dd><pre><code>var add = function(a, b, c, d, e) {
    return a + b + c + d + e;
};
var curryAll = Function.curry(add);
assert.equal(curryAll(1)(2)(3)(4)(5), 15);</code></pre></dd>
          </dl>
        </section>
        <section class="suite">
          <h1>#partial -- bind without changing the *this* value</h1>
          <dl>
            <dt>default partial</dt>
            <dd><pre><code>var add = function(a, b) {
    return a + b;
}
var _ = add.partial._;
var partial = add.partial(1);
assert.equal(partial(1), 2)
assert.equal(partial(2), 3)</code></pre></dd>
            <dt>fn.partial( _,*,_,_,* )</dt>
            <dd><pre><code>var add = function(a, b, c, d, e) {
    return a + b + c + d + e;
};
var _ = add.partial._;
var p1 = add.partial(1, _, _, 3, 4);
assert.equal(p1(2, 3), 13);</code></pre></dd>
            <dt>Function.partial(fn, _,****)</dt>
            <dd><pre><code>var add = function(a, b, c, d, e) {
    return a + b + c + d + e;
};
var _ = Function.partial._;
var p1 = Function.partial(add, _, _, 1, 3, 4);
assert.equal(p1(2, 3), 13);</code></pre></dd>
          </dl>
        </section>
        <section class="suite">
          <h1>#once -- function can only be called once</h1>
          <dl>
            <dt>fn.once()</dt>
            <dd><pre><code>var count = 0;
var acc = function() {
    count++
};
var once = acc.once();
once();
once();
once();
assert.equal(count, 1);</code></pre></dd>
            <dt>Function.once(fn)</dt>
            <dd><pre><code>var count = 0;
var acc = function() {
    count++
};
var once = Function.once(acc);
once();
once();
once();
assert.equal(count, 1);</code></pre></dd>
          </dl>
        </section>
        <section class="suite">
          <h1>#wrap -- return a new wrapped function</h1>
          <dl>
            <dt>fn.wrap(wrpper)</dt>
            <dd><pre><code>var add = function(a, b) {
    return a + b;
}
var wrapper = add.wrap(function(func, a, b) {
    return 1 + func(a, b);
});
assert.equal(wrapper(2, 3), 6);</code></pre></dd>
          </dl>
        </section>
        <section class="suite">
          <h1>#compose -- turn f(), g(), h() into f(g(h()))</h1>
          <dl>
            <dt>fn.compose(g,[h,[i...]])</dt>
            <dd><pre><code>var add = function(x) {
    return x + 1;
}
var squre = function(x) {
    return x * x
}
var add4 = function(x) {
    return x + 4;
}
var c = add.compose(squre, add4);
assert.equal(c(1), 26);</code></pre></dd>
            <dt>Function.compose(f,[g,[h...]])</dt>
            <dd><pre><code>var add = function(x) {
                return x + 1;
            }
            var squre = function(x) {
                return x * x
            }
            var add4 = function(x) {
                return x + 4;
            }
            var c = Function.compose(add, squre, add4);
            assert.equal(c(1), 26);</code></pre></dd>
          </dl>
        </section>
      </dl>
    </section>
    <section class="suite">
      <h1>#Array</h1>
      <dl>
        <section class="suite">
          <h1>creation</h1>
          <dl>
            <section class="suite">
              <h1>#dim(len,[initial]) -- create a array with length of len, initialized by initial</h1>
              <dl>
                <dt>Array.dim(len,[initial])</dt>
                <dd><pre><code>assert.deepEqual(Array.dim(4, 1), [1, 1, 1, 1]);</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#matrix(m,n,[initial]) -- create a m x n matrix with initial value</h1>
              <dl>
                <dt>Array.matrix(m,n,[initial])</dt>
                <dd><pre><code>var m = [
    [0, 0, 0],
    [0, 0, 0],
];
assert.deepEqual(Array.matrix(2, 3, 0), m);</code></pre></dd>
              </dl>
            </section>
          </dl>
        </section>
        <section class="suite">
          <h1>access</h1>
          <dl>
            <section class="suite">
              <h1>#pluck -- A short version of map, return a plain array contains the requested attribute regardless of any non-object arguments.</h1>
              <dl>
                <dt>arr.pluck(name)</dt>
                <dd><pre><code>var a = [{
    name: 'he'
}, undefined, {
    name: 'llo'
}, 'name', {
    name: ','
}, {
    name: 'world'
}, {}, {}];
assert.equal(a.pluck('name').join(''), 'hello,world');
assert.equal(a.pluck('name').join('!'), 'he!llo!,!world!!');</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#where -- similar to Array#filter but it takes a query-object rather than function as its argument)</h1>
              <dl>
                <dt>arr.where({...})</dt>
                <dd><pre><code>var data = [{
    name: 'a',
    id: 0
}, {
    id: 13,
    name: 'a'
}, {
    name: 'bdc',
    id: 1
}, {
    name: 'ap',
    id: 11
}, {
    name: 'o',
    id: 100
}, {
    id: 400
}];
assert.deepEqual(data.where({
    name: 'a'
}), [{
    name: 'a',
    id: 0
}, {
    id: 13,
    name: 'a'
}]);
assert.deepEqual(data.where({
    name: 'a',
    id: 13
}), [{
    name: 'a',
    id: 13
}]);</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#find -- find the first match the predicate</h1>
              <dl>
                <dt>arr.find(fn)</dt>
                <dd><pre><code>assert.equal(233, data.find(isObject).a);</code></pre></dd>
                <dt>Array.find(arr,fn)</dt>
                <dd><pre><code>assert.equal(233, Array.find(data, isObject).a);</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#first -- return first element of array</h1>
              <dl>
                <dt>arr.first()</dt>
                <dd><pre><code>var a = [];
var b = [2, 3, 4];
assert.equal(a.first(), void 0);
assert.equal(b.first(), 2);</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#last -- return last element of array</h1>
              <dl>
                <dt>arr.last()</dt>
                <dd><pre><code>var a = [];
                var b = [2, 3, 4];
                assert.equal(b.last(), 4);
                assert.equal(a.last(), void 0);</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#contains -- return true if the array contains the input</h1>
              <dl>
                <dt>arr.contains(obj)</dt>
                <dd><pre><code>var b = [23, 34, 5, 5, 6, 9, 7, 7, 7233, 8];
assert.equal(b.contains(23), true);
assert.equal(b.contains(22), false);</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#densify -- return a copy that contains no &quot;undifined&quot; element</h1>
              <dl>
                <dt>arr.densify()</dt>
                <dd><pre><code>var dirty = [undefined, 123, 4, undefined, 2, 555, undefined, 44, 2, undefined];
assert.deepEqual([123, 4, 2, 555, 44, 2], dirty.densify());</code></pre></dd>
                <dt>Array.densify(arr)</dt>
                <dd><pre><code>var dirty = [undefined, 123, 4, undefined, 2, 555, undefined, 44, 2, undefined];
assert.deepEqual([123, 4, 2, 555, 44, 2], Array.densify(dirty));</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>compact -- return a copy with all falsy elements removed</h1>
              <dl>
                <dt>arr.compact()</dt>
                <dd><pre><code>var dirty = [false, 123, 4, 0, 2, 555, NaN, 44, 2, undefined];
assert.deepEqual(dirty.compact(), [123, 4, 2, 555, 44, 2]);</code></pre></dd>
                <dt>Array.compact(arr)</dt>
                <dd><pre><code>var dirty = [false, 123, 4, 0, 2, 555, NaN, 44, 2, undefined];
assert.deepEqual(Array.compact(dirty), [123, 4, 2, 555, 44, 2]);</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#exclude -- return a copy with input elements removed</h1>
              <dl>
                <dt>arr.exclude(a,b,c....)</dt>
                <dd><pre><code>var arr = [1, 23, 4, 5, 55, 6, 7, 8, 9];
assert.deepEqual(arr.exclude(1, 4, 5, 6), [23, 55, 7, 8, 9]);</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#find -- return the first element meet the predicate</h1>
              <dl>
                <dt>arr.find(fn)</dt>
                <dd><pre><code>var a = [1, 23, 4, 5, 6, 73444, 5];
assert.equal(a.find(function(_) {
    return _ === 5;
}), 5);</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#findIndex -- return the index of  first element meets the predicate</h1>
              <dl>
                <dt>arr.findIndex(fn)</dt>
                <dd><pre><code>var a = [1, 23, 4, 5, 6, 73444, 5];
assert.equal(a.findIndex(function(_) {
    return _ === 5;
}), 3);</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#isEmpty -- return true if array.length === 0</h1>
              <dl>
                <dt>arr.isEmpty()</dt>
                <dd><pre><code>assert.equal([].isEmpty(), true);</code></pre></dd>
                <dt>Array.isEmpty(arr)</dt>
                <dd><pre><code>assert.equal(Object.isEmpty([]), true)
assert.equal(Array.isEmpty([]), true)
assert.equal(Array.isEmpty(null), true)
assert.equal(Array.isEmpty(undefined), true)</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#partition -- split into two arrays by the predicate, one whose elements all satisfy the predicate and one whose not</h1>
              <dl>
                <dt>arr.partition(fn)</dt>
                <dd><pre><code>assert.deepEqual([1, 2, 3, 4, 5, 6].partition(function(i) {
    return i % 2 === 0
}), [
    [2, 4, 6],
    [1, 3, 5]
]);</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#indexWhere -- similar to indexOf but recieves a function as its predicate</h1>
              <dl>
                <dt>arr.indexWhere(fn)</dt>
                <dd><pre><code>var data = [{
                    name: 'a',
                    id: 0
                }, {
                    id: 13,
                    name: 'a'
                }, {
                    name: 'bdc',
                    id: 1
                }, {
                    name: 'ap',
                    id: 11
                }, {
                    name: 'o',
                    id: 100
                }, {
                    id: 400
                }];
                assert.deepEqual(data.indexWhere({
                    name: 'a'
                }), [0, 1]);</code></pre></dd>
              </dl>
            </section>
            <section class="suite">
              <h1>#update -- update specified element with new value</h1>
              <dl>
                <dt>arr.update(index, newVal)</dt>
                <dd><pre><code>assert.deepEqual([1, 3, 3, 4, 5, 6].update(1, 2), [1, 2, 3, 4, 5, 6])</code></pre></dd>
              </dl>
            </section>
          </dl>
        </section>
        <section class="suite">
          <h1>extra &amp; experimental</h1>
          <dl>
            <section class="suite">
              <h1>#reductions -- similar to the Array.reduce except returns an array records every intermediate value</h1>
              <dl>
                <dt>arr.reductions(fn, [initial])</dt>
                <dd><pre><code>assert.deepEqual([1, 2, 3].reductions(function(acc, o) {
    return acc + o
}, 0), [1, 3, 6]);</code></pre></dd>
              </dl>
            </section>
          </dl>
        </section>
      </dl>
    </section>
